/**
 * TimeCountDown - 时间组件核心插件
 * 提供倒计时、环形倒计时、粒子倒计时等时间控制功能
 */

class TimeCountDown {
    constructor() {
        this._timers = new Map();
        this._callbacks = new Map();
        this._currentId = 0;
    }

    /**
     * 创建一个新的倒计时
     * @param {Number} duration 倒计时时长（毫秒）
     * @param {Number} interval 回调间隔（毫秒），默认1000ms
     * @param {Object} options 配置选项
     * @returns {Number} 倒计时ID
     */
    create(duration, interval = 1000, options = {}) {
        const id = ++this._currentId;
        const endTime = Date.now() + duration;
        
        this._callbacks.set(id, {
            onTick: options.onTick || null,
            onComplete: options.onComplete || null,
            onStart: options.onStart || null,
            formatTime: options.formatTime || this._defaultFormatTime
        });
        
        // 存储倒计时信息
        this._timers.set(id, {
            endTime,
            duration,
            interval,
            options,
            timerId: null,
            remaining: duration,
            state: 'created'
        });
        
        return id;
    }
    
    /**
     * 开始倒计时
     * @param {Number} id 倒计时ID
     */
    start(id) {
        if (!this._timers.has(id)) {
            console.error(`ID为${id}的倒计时不存在`);
            return;
        }
        
        const timer = this._timers.get(id);
        const callbacks = this._callbacks.get(id);
        
        // 如果已经在运行，则不做任何操作
        if (timer.state === 'running') return;
        
        // 如果是暂停状态，则使用剩余时间重新计算结束时间
        if (timer.state === 'paused') {
            timer.endTime = Date.now() + timer.remaining;
        }
        
        // 更新状态
        timer.state = 'running';
        
        // 触发开始回调
        if (callbacks.onStart && (timer.state !== 'paused' || timer.options.triggerStartOnResume)) {
            callbacks.onStart({
                id,
                duration: timer.duration,
                remaining: timer.remaining
            });
        }
        
        // 启动定时器
        this._tick(id);
    }
    
    /**
     * 暂停倒计时
     * @param {Number} id 倒计时ID
     */
    pause(id) {
        if (!this._timers.has(id)) {
            console.error(`ID为${id}的倒计时不存在`);
            return;
        }
        
        const timer = this._timers.get(id);
        
        // 如果不是运行状态，则不做任何操作
        if (timer.state !== 'running') return;
        
        // 清除定时器
        clearTimeout(timer.timerId);
        
        // 计算剩余时间
        timer.remaining = Math.max(0, timer.endTime - Date.now());
        
        // 更新状态
        timer.state = 'paused';
    }
    
    /**
     * 重置倒计时
     * @param {Number} id 倒计时ID
     * @param {Boolean} autoStart 是否自动开始
     */
    reset(id, autoStart = false) {
        if (!this._timers.has(id)) {
            console.error(`ID为${id}的倒计时不存在`);
            return;
        }
        
        const timer = this._timers.get(id);
        
        // 清除定时器
        if (timer.timerId) {
            clearTimeout(timer.timerId);
        }
        
        // 重置状态
        timer.remaining = timer.duration;
        timer.state = 'created';
        
        // 如果需要自动开始
        if (autoStart) {
            this.start(id);
        }
    }
    
    /**
     * 销毁倒计时
     * @param {Number} id 倒计时ID
     */
    destroy(id) {
        if (!this._timers.has(id)) {
            console.error(`ID为${id}的倒计时不存在`);
            return;
        }
        
        const timer = this._timers.get(id);
        
        // 清除定时器
        if (timer.timerId) {
            clearTimeout(timer.timerId);
        }
        
        // 移除数据
        this._timers.delete(id);
        this._callbacks.delete(id);
    }
    
    /**
     * 获取倒计时信息
     * @param {Number} id 倒计时ID
     * @returns {Object} 倒计时信息
     */
    getTimerInfo(id) {
        if (!this._timers.has(id)) {
            console.error(`ID为${id}的倒计时不存在`);
            return null;
        }
        
        const timer = this._timers.get(id);
        const remaining = timer.state === 'running' 
            ? Math.max(0, timer.endTime - Date.now()) 
            : timer.remaining;
            
        return {
            id,
            state: timer.state,
            duration: timer.duration,
            remaining,
            progress: Math.min(100, ((timer.duration - remaining) / timer.duration) * 100),
            formattedTime: this._callbacks.get(id).formatTime(remaining)
        };
    }
    
    /**
     * 内部计时器更新方法
     * @param {Number} id 倒计时ID
     * @private
     */
    _tick(id) {
        if (!this._timers.has(id)) return;
        
        const timer = this._timers.get(id);
        const callbacks = this._callbacks.get(id);
        
        // 如果不是运行状态，则不继续执行
        if (timer.state !== 'running') return;
        
        // 计算剩余时间
        const now = Date.now();
        const remaining = Math.max(0, timer.endTime - now);
        timer.remaining = remaining;
        
        // 调用tick回调
        if (callbacks.onTick) {
            callbacks.onTick({
                id,
                duration: timer.duration,
                remaining: remaining,
                progress: Math.min(100, ((timer.duration - remaining) / timer.duration) * 100),
                formattedTime: callbacks.formatTime(remaining)
            });
        }
        
        // 检查是否完成
        if (remaining <= 0) {
            timer.state = 'completed';
            if (callbacks.onComplete) {
                callbacks.onComplete({
                    id,
                    duration: timer.duration
                });
            }
            return;
        }
        
        // 计算下一次调用时间
        const delay = Math.min(remaining, timer.interval);
        
        // 设置下一次调用
        timer.timerId = setTimeout(() => this._tick(id), delay);
    }
    
    /**
     * 默认时间格式化函数
     * @param {Number} ms 毫秒数
     * @returns {Object} 格式化后的时间
     * @private
     */
    _defaultFormatTime(ms) {
        const totalSeconds = Math.floor(ms / 1000);
        const days = Math.floor(totalSeconds / (24 * 60 * 60));
        const hours = Math.floor((totalSeconds % (24 * 60 * 60)) / (60 * 60));
        const minutes = Math.floor((totalSeconds % (60 * 60)) / 60);
        const seconds = totalSeconds % 60;
        const milliseconds = Math.floor((ms % 1000) / 10);
        
        return {
            days,
            hours,
            minutes,
            seconds,
            milliseconds,
            formatted: `${days > 0 ? days + 'd ' : ''}${
                hours.toString().padStart(2, '0')}:${
                minutes.toString().padStart(2, '0')}:${
                seconds.toString().padStart(2, '0')}`
        };
    }
    
    /**
     * 销毁所有倒计时
     */
    destroyAll() {
        for (const id of this._timers.keys()) {
            this.destroy(id);
        }
    }
}

export default new TimeCountDown(); 